/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package entityprojet;

import entityprojet.exceptions.NonexistentEntityException;
import entityprojet.exceptions.PreexistingEntityException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;


/**
 *
 * @author Ron
 */
public class FProtectioncptaJpaController implements Serializable {

    public FProtectioncptaJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;
    
    public FProtectioncptaJpaController() {
        this.emf = Persistence.createEntityManagerFactory("projetT_RPU");
    }
    
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(FProtectioncpta FProtectioncpta) throws PreexistingEntityException, Exception {
        if (FProtectioncpta.getFProtectioncptaCollection() == null) {
            FProtectioncpta.setFProtectioncptaCollection(new ArrayList<FProtectioncpta>());
        }
        if (FProtectioncpta.getFCollaborateurCollection() == null) {
            FProtectioncpta.setFCollaborateurCollection(new ArrayList<FCollaborateur>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FProtectioncpta cbPROTUserProfil = FProtectioncpta.getCbPROTUserProfil();
            if (cbPROTUserProfil != null) {
                cbPROTUserProfil = em.getReference(cbPROTUserProfil.getClass(), cbPROTUserProfil.getCbMarq());
                FProtectioncpta.setCbPROTUserProfil(cbPROTUserProfil);
            }
            Collection<FProtectioncpta> attachedFProtectioncptaCollection = new ArrayList<FProtectioncpta>();
            for (FProtectioncpta FProtectioncptaCollectionFProtectioncptaToAttach : FProtectioncpta.getFProtectioncptaCollection()) {
                FProtectioncptaCollectionFProtectioncptaToAttach = em.getReference(FProtectioncptaCollectionFProtectioncptaToAttach.getClass(), FProtectioncptaCollectionFProtectioncptaToAttach.getCbMarq());
                attachedFProtectioncptaCollection.add(FProtectioncptaCollectionFProtectioncptaToAttach);
            }
            FProtectioncpta.setFProtectioncptaCollection(attachedFProtectioncptaCollection);
            Collection<FCollaborateur> attachedFCollaborateurCollection = new ArrayList<FCollaborateur>();
            for (FCollaborateur FCollaborateurCollectionFCollaborateurToAttach : FProtectioncpta.getFCollaborateurCollection()) {
                FCollaborateurCollectionFCollaborateurToAttach = em.getReference(FCollaborateurCollectionFCollaborateurToAttach.getClass(), FCollaborateurCollectionFCollaborateurToAttach.getCbMarq());
                attachedFCollaborateurCollection.add(FCollaborateurCollectionFCollaborateurToAttach);
            }
            FProtectioncpta.setFCollaborateurCollection(attachedFCollaborateurCollection);
            em.persist(FProtectioncpta);
            if (cbPROTUserProfil != null) {
                cbPROTUserProfil.getFProtectioncptaCollection().add(FProtectioncpta);
                cbPROTUserProfil = em.merge(cbPROTUserProfil);
            }
            for (FProtectioncpta FProtectioncptaCollectionFProtectioncpta : FProtectioncpta.getFProtectioncptaCollection()) {
                FProtectioncpta oldCbPROTUserProfilOfFProtectioncptaCollectionFProtectioncpta = FProtectioncptaCollectionFProtectioncpta.getCbPROTUserProfil();
                FProtectioncptaCollectionFProtectioncpta.setCbPROTUserProfil(FProtectioncpta);
                FProtectioncptaCollectionFProtectioncpta = em.merge(FProtectioncptaCollectionFProtectioncpta);
                if (oldCbPROTUserProfilOfFProtectioncptaCollectionFProtectioncpta != null) {
                    oldCbPROTUserProfilOfFProtectioncptaCollectionFProtectioncpta.getFProtectioncptaCollection().remove(FProtectioncptaCollectionFProtectioncpta);
                    oldCbPROTUserProfilOfFProtectioncptaCollectionFProtectioncpta = em.merge(oldCbPROTUserProfilOfFProtectioncptaCollectionFProtectioncpta);
                }
            }
            for (FCollaborateur FCollaborateurCollectionFCollaborateur : FProtectioncpta.getFCollaborateurCollection()) {
                FProtectioncpta oldCbPROTNoOfFCollaborateurCollectionFCollaborateur = FCollaborateurCollectionFCollaborateur.getCbPROTNo();
                FCollaborateurCollectionFCollaborateur.setCbPROTNo(FProtectioncpta);
                FCollaborateurCollectionFCollaborateur = em.merge(FCollaborateurCollectionFCollaborateur);
                if (oldCbPROTNoOfFCollaborateurCollectionFCollaborateur != null) {
                    oldCbPROTNoOfFCollaborateurCollectionFCollaborateur.getFCollaborateurCollection().remove(FCollaborateurCollectionFCollaborateur);
                    oldCbPROTNoOfFCollaborateurCollectionFCollaborateur = em.merge(oldCbPROTNoOfFCollaborateurCollectionFCollaborateur);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findFProtectioncpta(FProtectioncpta.getCbMarq()) != null) {
                throw new PreexistingEntityException("FProtectioncpta " + FProtectioncpta + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(FProtectioncpta FProtectioncpta) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FProtectioncpta persistentFProtectioncpta = em.find(FProtectioncpta.class, FProtectioncpta.getCbMarq());
            FProtectioncpta cbPROTUserProfilOld = persistentFProtectioncpta.getCbPROTUserProfil();
            FProtectioncpta cbPROTUserProfilNew = FProtectioncpta.getCbPROTUserProfil();
            Collection<FProtectioncpta> FProtectioncptaCollectionOld = persistentFProtectioncpta.getFProtectioncptaCollection();
            Collection<FProtectioncpta> FProtectioncptaCollectionNew = FProtectioncpta.getFProtectioncptaCollection();
            Collection<FCollaborateur> FCollaborateurCollectionOld = persistentFProtectioncpta.getFCollaborateurCollection();
            Collection<FCollaborateur> FCollaborateurCollectionNew = FProtectioncpta.getFCollaborateurCollection();
            if (cbPROTUserProfilNew != null) {
                cbPROTUserProfilNew = em.getReference(cbPROTUserProfilNew.getClass(), cbPROTUserProfilNew.getCbMarq());
                FProtectioncpta.setCbPROTUserProfil(cbPROTUserProfilNew);
            }
            Collection<FProtectioncpta> attachedFProtectioncptaCollectionNew = new ArrayList<FProtectioncpta>();
            for (FProtectioncpta FProtectioncptaCollectionNewFProtectioncptaToAttach : FProtectioncptaCollectionNew) {
                FProtectioncptaCollectionNewFProtectioncptaToAttach = em.getReference(FProtectioncptaCollectionNewFProtectioncptaToAttach.getClass(), FProtectioncptaCollectionNewFProtectioncptaToAttach.getCbMarq());
                attachedFProtectioncptaCollectionNew.add(FProtectioncptaCollectionNewFProtectioncptaToAttach);
            }
            FProtectioncptaCollectionNew = attachedFProtectioncptaCollectionNew;
            FProtectioncpta.setFProtectioncptaCollection(FProtectioncptaCollectionNew);
            Collection<FCollaborateur> attachedFCollaborateurCollectionNew = new ArrayList<FCollaborateur>();
            for (FCollaborateur FCollaborateurCollectionNewFCollaborateurToAttach : FCollaborateurCollectionNew) {
                FCollaborateurCollectionNewFCollaborateurToAttach = em.getReference(FCollaborateurCollectionNewFCollaborateurToAttach.getClass(), FCollaborateurCollectionNewFCollaborateurToAttach.getCbMarq());
                attachedFCollaborateurCollectionNew.add(FCollaborateurCollectionNewFCollaborateurToAttach);
            }
            FCollaborateurCollectionNew = attachedFCollaborateurCollectionNew;
            FProtectioncpta.setFCollaborateurCollection(FCollaborateurCollectionNew);
            FProtectioncpta = em.merge(FProtectioncpta);
            if (cbPROTUserProfilOld != null && !cbPROTUserProfilOld.equals(cbPROTUserProfilNew)) {
                cbPROTUserProfilOld.getFProtectioncptaCollection().remove(FProtectioncpta);
                cbPROTUserProfilOld = em.merge(cbPROTUserProfilOld);
            }
            if (cbPROTUserProfilNew != null && !cbPROTUserProfilNew.equals(cbPROTUserProfilOld)) {
                cbPROTUserProfilNew.getFProtectioncptaCollection().add(FProtectioncpta);
                cbPROTUserProfilNew = em.merge(cbPROTUserProfilNew);
            }
            for (FProtectioncpta FProtectioncptaCollectionOldFProtectioncpta : FProtectioncptaCollectionOld) {
                if (!FProtectioncptaCollectionNew.contains(FProtectioncptaCollectionOldFProtectioncpta)) {
                    FProtectioncptaCollectionOldFProtectioncpta.setCbPROTUserProfil(null);
                    FProtectioncptaCollectionOldFProtectioncpta = em.merge(FProtectioncptaCollectionOldFProtectioncpta);
                }
            }
            for (FProtectioncpta FProtectioncptaCollectionNewFProtectioncpta : FProtectioncptaCollectionNew) {
                if (!FProtectioncptaCollectionOld.contains(FProtectioncptaCollectionNewFProtectioncpta)) {
                    FProtectioncpta oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta = FProtectioncptaCollectionNewFProtectioncpta.getCbPROTUserProfil();
                    FProtectioncptaCollectionNewFProtectioncpta.setCbPROTUserProfil(FProtectioncpta);
                    FProtectioncptaCollectionNewFProtectioncpta = em.merge(FProtectioncptaCollectionNewFProtectioncpta);
                    if (oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta != null && !oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta.equals(FProtectioncpta)) {
                        oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta.getFProtectioncptaCollection().remove(FProtectioncptaCollectionNewFProtectioncpta);
                        oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta = em.merge(oldCbPROTUserProfilOfFProtectioncptaCollectionNewFProtectioncpta);
                    }
                }
            }
            for (FCollaborateur FCollaborateurCollectionOldFCollaborateur : FCollaborateurCollectionOld) {
                if (!FCollaborateurCollectionNew.contains(FCollaborateurCollectionOldFCollaborateur)) {
                    FCollaborateurCollectionOldFCollaborateur.setCbPROTNo(null);
                    FCollaborateurCollectionOldFCollaborateur = em.merge(FCollaborateurCollectionOldFCollaborateur);
                }
            }
            for (FCollaborateur FCollaborateurCollectionNewFCollaborateur : FCollaborateurCollectionNew) {
                if (!FCollaborateurCollectionOld.contains(FCollaborateurCollectionNewFCollaborateur)) {
                    FProtectioncpta oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur = FCollaborateurCollectionNewFCollaborateur.getCbPROTNo();
                    FCollaborateurCollectionNewFCollaborateur.setCbPROTNo(FProtectioncpta);
                    FCollaborateurCollectionNewFCollaborateur = em.merge(FCollaborateurCollectionNewFCollaborateur);
                    if (oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur != null && !oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur.equals(FProtectioncpta)) {
                        oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur.getFCollaborateurCollection().remove(FCollaborateurCollectionNewFCollaborateur);
                        oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur = em.merge(oldCbPROTNoOfFCollaborateurCollectionNewFCollaborateur);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = FProtectioncpta.getCbMarq();
                if (findFProtectioncpta(id) == null) {
                    throw new NonexistentEntityException("The fProtectioncpta with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FProtectioncpta FProtectioncpta;
            try {
                FProtectioncpta = em.getReference(FProtectioncpta.class, id);
                FProtectioncpta.getCbMarq();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The FProtectioncpta with id " + id + " no longer exists.", enfe);
            }
            FProtectioncpta cbPROTUserProfil = FProtectioncpta.getCbPROTUserProfil();
            if (cbPROTUserProfil != null) {
                cbPROTUserProfil.getFProtectioncptaCollection().remove(FProtectioncpta);
                cbPROTUserProfil = em.merge(cbPROTUserProfil);
            }
            Collection<FProtectioncpta> FProtectioncptaCollection = FProtectioncpta.getFProtectioncptaCollection();
            for (FProtectioncpta FProtectioncptaCollectionFProtectioncpta : FProtectioncptaCollection) {
                FProtectioncptaCollectionFProtectioncpta.setCbPROTUserProfil(null);
                FProtectioncptaCollectionFProtectioncpta = em.merge(FProtectioncptaCollectionFProtectioncpta);
            }
            Collection<FCollaborateur> FCollaborateurCollection = FProtectioncpta.getFCollaborateurCollection();
            for (FCollaborateur FCollaborateurCollectionFCollaborateur : FCollaborateurCollection) {
                FCollaborateurCollectionFCollaborateur.setCbPROTNo(null);
                FCollaborateurCollectionFCollaborateur = em.merge(FCollaborateurCollectionFCollaborateur);
            }
            em.remove(FProtectioncpta);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<FProtectioncpta> findFProtectioncptaEntities() {
        return findFProtectioncptaEntities(true, -1, -1);
    }

    public List<FProtectioncpta> findFProtectioncptaEntities(int maxResults, int firstResult) {
        return findFProtectioncptaEntities(false, maxResults, firstResult);
    }

    private List<FProtectioncpta> findFProtectioncptaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(FProtectioncpta.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public FProtectioncpta findFProtectioncpta(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(FProtectioncpta.class, id);
        } finally {
            em.close();
        }
    }

    public int getFProtectioncptaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<FProtectioncpta> rt = cq.from(FProtectioncpta.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
